<!DOCTYPE html>
<html lang="en" dir="auto">

<head><meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<meta name="robots" content="index, follow">
<title>Pytorch的使用 | flipped</title>
<meta name="keywords" content="Pytorch" />
<meta name="description" content="Guide for pytorch">
<meta name="author" content="flipped">
<link rel="canonical" href="http://zouheng22.gitee.io/flippedzh/posts/pytorch%E4%BD%BF%E7%94%A8/" />
<link crossorigin="anonymous" href="/flippedzh/assets/css/stylesheet.min.2d6dbfc6e0f8a1db1c9d082a76dc11d094328cf63f247bbc2421dfaa7f2bb170.css" integrity="sha256-LW2/xuD4odscnQgqdtwR0JQyjPY/JHu8JCHfqn8rsXA=" rel="preload stylesheet" as="style">
<script defer crossorigin="anonymous" src="/flippedzh/assets/js/highlight.min.7680afc38aa6b15ddf158a4f3780b7b1f7dde7e91d26f073e6229bb7a0793c92.js" integrity="sha256-doCvw4qmsV3fFYpPN4C3sffd5&#43;kdJvBz5iKbt6B5PJI="
    onload="hljs.initHighlightingOnLoad();"></script>
<link rel="icon" href="http://zouheng22.gitee.io/flippedzh/favicon.ico">
<link rel="icon" type="image/png" sizes="16x16" href="http://zouheng22.gitee.io/flippedzh/favicon-16x16.png">
<link rel="icon" type="image/png" sizes="32x32" href="http://zouheng22.gitee.io/flippedzh/favicon-32x32.png">
<link rel="apple-touch-icon" href="http://zouheng22.gitee.io/flippedzh/apple-touch-icon.png">
<link rel="mask-icon" href="http://zouheng22.gitee.io/flippedzh/safari-pinned-tab.svg">
<meta name="theme-color" content="#2e2e33">
<meta name="msapplication-TileColor" content="#2e2e33">
<meta name="generator" content="Hugo 0.83.1" />
<link rel="alternate" hreflang="en" href="http://zouheng22.gitee.io/flippedzh/posts/pytorch%E4%BD%BF%E7%94%A8/" />
<meta property="og:title" content="Pytorch的使用" />
<meta property="og:description" content="Guide for pytorch" />
<meta property="og:type" content="article" />
<meta property="og:url" content="http://zouheng22.gitee.io/flippedzh/posts/pytorch%E4%BD%BF%E7%94%A8/" /><meta property="og:image" content="http://zouheng22.gitee.io/flippedzh/papermod-cover.png"/><meta property="article:section" content="posts" />
<meta property="article:published_time" content="2021-12-10T15:04:49&#43;08:00" />
<meta property="article:modified_time" content="2021-12-10T15:04:49&#43;08:00" />


<meta name="twitter:card" content="summary_large_image"/>
<meta name="twitter:image" content="http://zouheng22.gitee.io/flippedzh/papermod-cover.png"/>

<meta name="twitter:title" content="Pytorch的使用"/>
<meta name="twitter:description" content="Guide for pytorch"/>


<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [, 
    {
      "@type": "ListItem",
      "position":  2 ,
      "name": "Posts",
      "item": "http://zouheng22.gitee.io/flippedzh/posts/"
    }, 
    {
      "@type": "ListItem",
      "position":  3 ,
      "name": "Pytorch的使用",
      "item": "http://zouheng22.gitee.io/flippedzh/posts/pytorch%E4%BD%BF%E7%94%A8/"
    }
  ]
}
</script>
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Pytorch的使用",
  "name": "Pytorch的使用",
  "description": "Guide for pytorch",
  "keywords": [
    "Pytorch"
  ],
  "articleBody": "  Pytorch中Softmax和LogSoftmax的使用\nSoftmax函数常用的用法是指定参数dim就可以：\n dim=0：对每一列的所有元素进行softmax运算，并使得每一列所有元素和为1。 dim=1：对每一行的所有元素进行softmax运算，并使得每一行所有元素和为1。  LogSoftmax其实就是对softmax的结果进行log，即Log(Softmax(x))\n  torch的方法：\n torch.normal: 正态分布  x1_t = torch.normal(均值,标准差)\r torch.cat:张量连接   torch.cat((张量1，张量2),0/1) # 按行/列连接\r torch.nn：包含常用网络单元/函数(激活与损失) torch.optim： 优化器     逻辑回归与线性回归(分类与回归)\n  线性回归\n 目的:找出拟合的直线 输出类型：连续的数据    逻辑回归\n 目的:找到决策面(分类问题) 输出类型：离散数据(标签)      正则化(解决泛化误差的方法) 等价于 带约束条件 （因此可以降低模型的复杂度）精辟好懂的讲解\n  理解为什么会有过拟合的问题产生？精辟好懂的讲解\n  规范模型参数的方法：L1(l1范数:正方形) L2(l2范数:圆形)主要是对参数w进行规范\n只有当p=1的时候，构成的集合才是凸集:\n曼哈顿距离 ：l1 欧几里得距离:l2\n  在约束条件下求最小值:   为什么正则化可以防止过拟合?\n  L1与L2的区别? L1的解不稳定\n  dropout\n    贝叶斯公式的理解 参考视频\n 利用贝叶斯公式理解神经网络\n总结来说就是： 在神经网络没训练之前的输出结果就可以理解为先验概率，在神经网络训练之后，输出结果可以理解为后验概率  贝叶斯公式：  利用贝叶斯公式理解正则化\n 似然函数\n获取一个系统确定的值  最大似然估计(不严谨的估计) (最大似然值)  最大后验估计\n      dropout解决过拟合问题\n传闻 kaggle比赛中有一种方法可以提高比赛成绩，那就是用多个模型训练同一数据集，即集成学习，但是运算量很大。 dropout在训练阶段的每个batch通过随机选择网络中的神经元并将其临时失效，这样模拟多个不同的模型来训练同一数据集。并在测试的时候，考虑到每个神经元都有失效过，所以通过在权重w上乘以一个概率p来模拟训练的过程，这样可以减少测试时的计算量。（测试集纯粹是为了测试已经训练好的模型的分类能力的样本集）\n  卷积的理解\n  https://www.bilibili.com/video/BV1sb411P7pQ?from=search\u0026seid=13442774822424625456\u0026spm_id_from=333.337.0.0\n 网络搭建模板：\nclass NetWork(nn.Module):\rdef __init__(self,n_input,n_hidden,n_output):\rsuper(NetWork,self).__init__()\rself.hidden = nn.Linear(n_input, n_hidden)\rself.output_for_predict = nn.Linear(n_hidden, n_output)\rdef forward(self, x):\rx = F.relu(self.hidden(x))\rx = self.output_for_predict(x)\rreturn x\rnetwork = NetWork(n_input = 1,n_hidden = 8, n_output = 2) print(network) #打印网络结构\r  优化器算法： 都是基于梯度下降算法 视频讲解\nsgd算法=miniBatchSGD\nAdam=sgd+一阶动量+二阶动量(下降快，同时避免局部最优)\n——Adam那么棒，为什么还对SGD念念不忘\n  pytorch的优化器以及参数：链接\n  不同的样本数量对梯度计算的影响 :     pytorch调用GPU训练\n  channel batch channel的两个来源：\n最初输入的图片样本的 channels ，取决于图片类型，比如RGB； 卷积操作完成后输出的 out_channels ，取决于卷积核的数量。此时的 out_channels 也会作为下一次卷积时的卷积核的 in_channels；\n  BN的原理：？？？？？？？？？？？？？？？？ https://blog.csdn.net/u011511601/article/details/79784960\n  batch: 一个batch就是Batch中的蓝色部分，batchsize=N\n10:09\nhttps://www.bilibili.com/video/BV1Ey4y1h7Ke?from=search\u0026seid=12160562612400132573\u0026spm_id_from=333.337.0.0 01:44\n5分钟理解BatchNorm:\nhttps://www.bilibili.com/video/BV1DM4y1w7J4?from=search\u0026seid=18068463749154619980\u0026spm_id_from=333.337.0.0\nNCHW ：图片数通道数特征图高 特征图宽\n数据排布格式（format） 在深度学习框架中，多维数据通过多维数组存储，比如卷积神经网络的特征图用 四维 数组保存，四个维度分别为批量大小（Batch, N）、特征图高度（Height, H）、特征图宽度（Width, W）以及特征图通道（Channels, C）。\n由于数据只能线性存储，因为这四个维度有对应的顺序。\nInstance Norm才是对一张特征图进行归一化： 特征：\n卷积核可以提取出原图中对应该卷积核的特征，表现形式为卷积之后的featureMapd中对应位置的权重大。\n最后经过全连接层 计算分类概率： (我觉得是包含两部分的工作)\n 属于某一类别的训练样本的输出，在经过反向传播的参数修正之后，增大了权重，多次训练之后多次更新权重，那些能代表类别的特征连接的权重肯定大，输入的值经过mlp的权重w计算之后肯定能贡献给softmax的输出层 更大的数值，表现为分类概率\n理解CNN的平移、尺度不变性：\n对于全连接网络，由于下一层的每个节点都会与上一层进行连接,因此无论输入发生了平移、尺度等什么变换，只要其属性没变，全连接网络更能捕捉其中的不变性。 (因为最终输出是一整个特征图的统计结果，所以不受位置影响) CNN就是计算原图中的特征的概率分布  补充：\n权重是如何变得有差异的？ 在猫与狗的分类问题中：耳朵是共同特征，所以第一个权重很大，表示这个特征很重要，在全连接层后发现输入是狗耳朵的可能性更大，所以连接狗的权重大。这样权重系数就有了差异 理解神经网络： 可以类比傅里叶级数，将复杂 函数拆解为正弦波，类似的神经网络也是将复杂函数拆解为一个一个的感知机(全连接层+激活层==线性函数+激活函数) 只要神经网络有一个隐藏层，那么他就可以逼近任意一个连续函数\n理解激活函数：视频 –可视化\n全连接层就是世界观\n激活函数就是价值观\n归一化： 归一化是将像素值进行归一化，而不是将。。。\n池化： Max Pooling (√) Mean Pooling\n 激活函数的作用 归一化 不需要人工构建特征，而是自动学习特征 什么情况下，会出现梯度消失 像素归一化 与 分布归一化  像素值归一化： 如果输入层 x 很大，在反向传播时候传递到输入层的梯度就会变得很大。梯度大，学习率就得非常小，否则会越过最优。在这种情况下，学习率的选择需要参考输入层数值大小，而直接将数据归一化操作，能很方便的选择学习率。（统一标准）\n分布归一化：(零均值归一化)\n  理论认识：\n 归一化的目的是希望输入数据的不同维度的特征具有相近的取值范围，从而能够更快的通过梯度下降找到最优解。链接 尝试解决ICS问题 避免整体分布逐渐往激活函数的饱和区间移动将每一层的输入作为一个分布看待，由于底层的参数随着训练更新，导致相同的输入分布得到的输出分布改变了。而机器学习中有个很重要的假设：IID独立同分布假设，就是假设训练数据和测试数据是满足相同分布的，这是通过训练数据获得的模型能够在测试集获得好的效果的一个基本保障。(在训练过程中，随着网络加深，分布逐渐发生变动，导致整体分布逐渐往激活函数的饱和区间移动，从而反向传播时底层出现梯度消失，也就是收敛越来越慢的原因。) 加速收敛：\n标准化其实就是把大部分激活的值落入非线性函数的线性区内，其对应的导数远离导数饱和区，这样来加速训练收敛过程。\n但是：\n如果使用标准化，那就相当于把非线性激活函数替换成线性函数了。那么使用非线性激活的意义在哪里呢，多层线性网络跟一层线性网络是等价的，也就是网络的表达能力下降了。 为了保证非线性表达能力，后面又对此打了个补丁，对变换后的满足均值为0方差为1的x进行了scale加上shift操作，形成类似y = s c a l e ∗ x + s h i f t y=scale*x+shifty=scale∗x+shift这种形式 链接    直观认识： 一般归一化还会做减去均值除以方差的操作, 这种方式可以移除图像的平均亮度值 (intensity)。很多情况下我们对图像的亮度并不感兴趣，而更多地关注其内容，比如在目标识别任务中，图像的整体明亮程度并不会影响图像中存在的是什么物体。此时，在每个样本上减去数据的统计平均值可以移除共同的部分，凸显个体差异。其效果如下所示：   注意：归一化有一个能进行的前提，神经网络的训练的目的是为了得到一个分布，而不是输出准确值，所以进行分布的变换是可以不影响结果，但是可以加快收敛速度，避免梯度消失。\n归一化发生在训练的各个阶段：\n输入归一化、批量归一化(BN)与层归一化(LN)、输出归一化。 yolov5修改网络 (https://www.bilibili.com/video/BV18K411n7rc/?spm_id_from=333.788.recommend_more_video.5)\nbatchsize的设置： https://www.zhihu.com/question/32673260\nbatchsize变大：（因为采样扔掉的数据就越多，一个epoch花的时间就约少） 一个epoch中迭代的次数少， 运算时间少（但是总体时间不一定变少） 过大会导致，达到相同的精度需要更多的epoch\nbatchsize变小： 运算时间大，\n区别fullbatch与随机梯度下降的区别： 随机梯度下降是为了解决fullbatch的问题 minbatch又是为了解决随机梯度下降的问题 所以现在pytorch中用的sdg==小批量梯度下降（mini-batch gradient decent） https://blog.csdn.net/weixin_45698935/article/details/106477624\nhttps://www.pianshen.com/article/95021129552/ https://blog.csdn.net/djfjkj52/article/details/116584633 https://www.zhihu.com/question/32673260 对于一个大小为N的训练集，如果每个epoch中mini-batch的采样方法采用最常规的N个样本每个都采样一次，设mini-batch大小为b，那么每个epoch所需的迭代次数(正向+反向)为 , 因此完成每个epoch所需的时间大致也随着迭代次数的增加而增加。 由于目前主流深度学习框架处理mini-batch的反向传播时，默认都是先将每个mini-batch中每个instance得到的loss平均化之后再反求梯度，也就是说每次反向传播的梯度是对mini-batch中每个instance的梯度平均之后的结果，所以b的大小决定了相邻迭代之间的梯度平滑程度，b太小，相邻mini-batch间的差异相对过大，那么相邻两次迭代的梯度震荡情况会比较严重，不利于收敛；b越大，相邻mini-batch间的差异相对越小，虽然梯度震荡情况会比较小，一定程度上利于模型收敛，但如果b极端大，相邻mini-batch间的差异过小，相邻两个mini-batch的梯度没有区别了，整个训练过程就是沿着一个方向蹭蹭蹭往下走，很容易陷入到局部最小值出不来。 。 原文链接：https://blog.csdn.net/weixin_39946266/article/details/111629858\n实验后确实 大点快\n 读代码\n  CNN为什么要接激活函数,与全连接层的激活函数有何区别？\n卷积部分的激活函数可以提取更深层特征，全连接层的激活函数可以增加模型的非线性拟合能力！\n进一步理解，首先回答以下几个问题：\n CNN为什么要有多层卷积？\n如果堆叠了多层卷积层，则随着层次加深，提取的信息也愈加复杂、抽象，这是深度学习中很有意思的一个地方。最开始的层对简单的边缘有响应，接下来的层对纹理有响应，再后面的层对更加复杂的物体部件有响应。也就是说，随着层次加深，神经元从简单的形状向“高级”信息变化。换句话说，就像我们理解东西的“含义”一样，响应的对象在逐渐变化。 为什么要加relu函数？\n因为卷积操作是一种线性操作,多层的线性操作时没有意义的，所以必须加入非线性的因素才能实现多层的效果。只有非线性的多层才能提取更加抽象的特征。 担心在卷积的过程中丢失过多的图像信息？\n在卷积的过程中，每一个卷积核对应着一个通道，那么每一个卷积核在进行卷积运算的时候，本来就是只需要有关图像的一丁点信息，只要你的卷积核够多，我觉得最后的featureMap还是能表征图像的。所以在经过一个卷积层的时候，进行一些抹零操作（激活）是不用担心的。抹的越多说不定这个特征越能代表该类别的底层特征，也能减少过拟合的情况（理解relu缓解过拟合）  就是说relu不仅仅增加了非线性的表达能力，而且还有其他作用，比如\n  CNN部分的输入输出情况是怎么样？\n# 定义CNN ：网络的复杂程度影响了一个epoch的运算时间（当然还有数据的数量）\rclass CNN(nn.Module):\rdef __init__(self):\rsuper(CNN,self).__init__()\r## 输入数据格式 [N C H W]\rself.layer1 = nn.Sequential(\r### 参数:输入通道数 输出通道数 卷积核大小\rnn.Conv2d(1,16,kernel_size=3), # 16, [26 ,26]\rnn.BatchNorm2d(16),\rnn.ReLU(inplace=True))\rself.layer2 = nn.Sequential(\rnn.Conv2d(16,32,kernel_size=3),# 32,[ 24, 24]\rnn.BatchNorm2d(32),\r# inplace表示覆盖运算\rnn.ReLU(inplace=True),\rnn.MaxPool2d(kernel_size=2,stride=2)) # 32,[ 12,12 ] (24-2) /2 +1\rself.layer3 = nn.Sequential(\rnn.Conv2d(32,64,kernel_size=3), # 64,[10,10]\rnn.BatchNorm2d(64),\rnn.ReLU(inplace=True))\rself.layer4 = nn.Sequential(\rnn.Conv2d(64,128,kernel_size=3), # 128,[8,8]\rnn.BatchNorm2d(128),\rnn.ReLU(inplace=True),\rnn.MaxPool2d(kernel_size=2,stride=2)) # 128, [4,4]\rself.fc = nn.Sequential(\rnn.Linear(128 * 4 * 4,1024),\rnn.ReLU(inplace=True),\rnn.Linear(1024,128),\rnn.ReLU(inplace=True),\rnn.Linear(128,10))\rdef forward(self,x):\rx = self.layer1(x)\rx = self.layer2(x)\rx = self.layer3(x)\rx = self.layer4(x)\r## view与reshape类似 将前面多维度的tensor展平成一维\r## 参数： 10000=batchSize 128*4*4\rx = x.view(x.size(0),-1)\rx = self.fc(x)\rreturn x\r  Tensor数据为什么展平了还是28*28？\n展平是说在物理空间的存储上是展平了的。是底层是展平存储的。\n  就是说输入到网络的还是28*28，只是底层是展平存储的\n典型的CNN代码 详解与注释\n  感知机的训练\n感知机的预测\nCNN的训练\nCNN的预测\n",
  "wordCount" : "372",
  "inLanguage": "en",
  "datePublished": "2021-12-10T15:04:49+08:00",
  "dateModified": "2021-12-10T15:04:49+08:00",
  "author":{
    "@type": "Person",
    "name": "flipped"
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "http://zouheng22.gitee.io/flippedzh/posts/pytorch%E4%BD%BF%E7%94%A8/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "flipped",
    "logo": {
      "@type": "ImageObject",
      "url": "http://zouheng22.gitee.io/flippedzh/favicon.ico"
    }
  }
}
</script>
</head>

<body class="" id="top">
<script>
    if (localStorage.getItem("pref-theme") === "dark") {
        document.body.classList.add('dark');
    } else if (localStorage.getItem("pref-theme") === "light") {
        document.body.classList.remove('dark')
    } else if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
        document.body.classList.add('dark');
    }

</script>
<noscript>
    <style type="text/css">
        #theme-toggle,
        .top-link {
            display: none;
        }

    </style>
    <style>
        @media (prefers-color-scheme: dark) {
            :root {
                --theme: #1d1e20;
                --entry: #2e2e33;
                --primary: rgba(255, 255, 255, 0.84);
                --secondary: rgba(255, 255, 255, 0.56);
                --tertiary: rgba(255, 255, 255, 0.16);
                --content: rgba(255, 255, 255, 0.74);
                --hljs-bg: #2e2e33;
                --code-bg: #37383e;
                --border: #333;
            }

            .list {
                background: var(--theme);
            }

            .list:not(.dark)::-webkit-scrollbar-track {
                background: 0 0;
            }

            .list:not(.dark)::-webkit-scrollbar-thumb {
                border-color: var(--theme);
            }
        }

    </style>
</noscript>

<header class="header">
    <nav class="nav">
        <div class="logo">
            <a href="http://zouheng22.gitee.io/flippedzh" accesskey="h" title="flipped (Alt + H)">flipped</a>
            <span class="logo-switches">
                <button id="theme-toggle" accesskey="t" title="(Alt + T)">
                    <svg id="moon" xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"
                        fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
                        stroke-linejoin="round">
                        <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"></path>
                    </svg>
                    <svg id="sun" xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"
                        fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
                        stroke-linejoin="round">
                        <circle cx="12" cy="12" r="5"></circle>
                        <line x1="12" y1="1" x2="12" y2="3"></line>
                        <line x1="12" y1="21" x2="12" y2="23"></line>
                        <line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line>
                        <line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line>
                        <line x1="1" y1="12" x2="3" y2="12"></line>
                        <line x1="21" y1="12" x2="23" y2="12"></line>
                        <line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line>
                        <line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line>
                    </svg>
                </button>
                
            </span>
        </div>
        <ul id="menu">
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/archives/" title="文章">
                    <span>文章</span>
                </a>
            </li>
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/categories" title="目录">
                    <span>目录</span>
                </a>
            </li>
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/tags" title="标签">
                    <span>标签</span>
                </a>
            </li>
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/series" title="系列">
                    <span>系列</span>
                </a>
            </li>
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/search/" title="搜索">
                    <span>搜索</span>
                </a>
            </li>
            <li>
                <a href="http://zouheng22.gitee.io/flippedzh/fr" title="关于我">
                    <span>关于我</span>
                </a>
            </li>
        </ul>
    </nav>
</header>
<main class="main">

<article class="post-single">
  <header class="post-header">
    <div class="breadcrumbs"><a href="http://zouheng22.gitee.io/flippedzh">Home</a>&nbsp;»&nbsp;<a href="http://zouheng22.gitee.io/flippedzh/posts/">Posts</a></div>
    <h1 class="post-title">
      Pytorch的使用
    </h1>
    <div class="post-description">
      Guide for pytorch
    </div>
    <div class="post-meta">December 10, 2021&nbsp;·&nbsp;2 min&nbsp;·&nbsp;flipped
</div>
  </header> <div class="toc">
    <details  open>
        <summary accesskey="c" title="(Alt + C)">
            <div class="details">Table of Contents</div>
        </summary>
        <div class="inner">
        </div>
    </details>
</div>

  <div class="post-content"><ol>
<li>
<p><a href="https://zhuanlan.zhihu.com/p/137791367">Pytorch中Softmax和LogSoftmax的使用</a></p>
<p>Softmax函数常用的用法是指定参数dim就可以：</p>
<ul>
<li>dim=0：对每一列的所有元素进行softmax运算，并使得每一列所有元素和为1。</li>
<li>dim=1：对每一行的所有元素进行softmax运算，并使得每一行所有元素和为1。</li>
</ul>
<p>LogSoftmax其实就是对softmax的结果进行log，即Log(Softmax(x))</p>
</li>
<li>
<p>torch的方法：</p>
<ul>
<li>torch.normal: 正态分布</li>
</ul>
<pre><code>x1_t = torch.normal(均值,标准差)
</code></pre><ul>
<li>torch.cat:张量连接</li>
</ul>
<pre><code> torch.cat((张量1，张量2),0/1) # 按行/列连接
</code></pre><ul>
<li>torch.nn：包含常用网络单元/函数(激活与损失)</li>
<li>torch.optim： 优化器</li>
<li></li>
</ul>
</li>
<li>
<p>逻辑回归与线性回归(分类与回归)</p>
<ul>
<li>
<p>线性回归</p>
<ul>
<li>目的:找出拟合的直线</li>
<li>输出类型：连续的数据</li>
</ul>
</li>
<li>
<p>逻辑回归</p>
<ul>
<li>目的:找到决策面(分类问题)</li>
<li>输出类型：离散数据(标签)</li>
</ul>
</li>
</ul>
</li>
<li>
<p>正则化(解决泛化误差的方法) 等价于 带约束条件  （因此可以降低模型的复杂度）<a href="https://www.bilibili.com/video/BV1Z44y147xA?from=search&amp;seid=12491640297443964754&amp;spm_id_from=333.337.0.0">精辟好懂的讲解</a></p>
<ul>
<li>
<p>理解为什么会有过拟合的问题产生？<a href="https://www.bilibili.com/video/BV1Z44y147xA?from=search&amp;seid=12491640297443964754&amp;spm_id_from=333.337.0.0">精辟好懂的讲解</a></p>
</li>
<li>
<p>规范模型参数的方法：L1(l1范数:正方形) L2(l2范数:圆形)主要是对参数w进行规范<br>
只有当p&gt;=1的时候，构成的集合才是凸集:<br>
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%E5%87%B8%E9%9B%86.jpg" alt="凸集"  />

曼哈顿距离 ：l1
欧几里得距离:l2</p>
</li>
<li>
<p>在约束条件下求最小值:
<img src="https://zouheng22.gitee.io/images_-cabin/research/正则化.jpg"></p>
</li>
</ul>
<p>为什么正则化可以防止过拟合?</p>
<ul>
<li>
<p>L1与L2的区别?
L1的解不稳定</p>
</li>
<li>
<p>dropout</p>
</li>
</ul>
</li>
<li>
<p>贝叶斯公式的理解 <a href="https://www.bilibili.com/video/BV1fR4y177jP?spm_id_from=333.999.0.0">参考视频</a></p>
<ul>
<li>利用贝叶斯公式理解神经网络<br>
总结来说就是： 在神经网络没训练之前的输出结果就可以理解为先验概率，在神经网络训练之后，输出结果可以理解为后验概率</li>
</ul>
<p>贝叶斯公式：
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e8%b4%9d%e5%8f%b6%e6%96%af%e5%85%ac%e5%bc%8f.jpg" alt="贝叶斯公式"  />
</p>
<ul>
<li>利用贝叶斯公式理解正则化<br>
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e8%b4%9d%e5%8f%b6%e6%96%af%e6%8e%a8%e5%af%bc.jpg" alt="贝叶斯推导"  />

<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e8%b4%9d%e5%8f%b6%e6%96%af%e6%8e%a8%e5%af%bc%e6%ad%a3%e5%88%99%e5%8c%96.jpg" alt="贝叶斯推导正则化"  />

<ul>
<li>似然函数<br>
获取一个系统确定的值
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e4%bc%bc%e7%84%b6%e5%87%bd%e6%95%b0.jpg" alt="似然函数"  />
</li>
<li>最大似然估计(不严谨的估计) (最大似然值) 
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e6%9c%80%e5%a4%a7%e4%bc%bc%e7%84%b6%e4%bc%b0%e8%ae%a1.jpg" alt="最大似然值"  />
</li>
<li>最大后验估计<br>
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/%e6%9c%80%e5%a4%a7%e5%90%8e%e9%aa%8c%e4%bc%b0%e8%ae%a1.jpg" alt="最大后验估计"  />
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>dropout解决过拟合问题<br>
<img loading="lazy" src="https://zouheng22.gitee.io/images_-cabin/research/dropout.jpg" alt="dropout"  />
<br>
传闻 kaggle比赛中有一种方法可以提高比赛成绩，那就是用多个模型训练同一数据集，即集成学习，但是运算量很大。
dropout在训练阶段的每个batch通过随机选择网络中的神经元并将其临时失效，这样模拟多个不同的模型来训练同一数据集。并在测试的时候，考虑到每个神经元都有失效过，所以通过在权重w上乘以一个概率p来模拟训练的过程，这样可以减少测试时的计算量。（测试集纯粹是为了测试已经训练好的模型的分类能力的样本集）</p>
</li>
<li>
<p><a href="https://www.bilibili.com/video/BV1VV411478E?spm_id_from=333.999.0.0">卷积的理解</a></p>
</li>
</ol>
<p><a href="https://www.bilibili.com/video/BV1sb411P7pQ?from=search&amp;seid=13442774822424625456&amp;spm_id_from=333.337.0.0">https://www.bilibili.com/video/BV1sb411P7pQ?from=search&amp;seid=13442774822424625456&amp;spm_id_from=333.337.0.0</a></p>
<ol start="7">
<li>
<p>网络搭建模板：</p>
<pre><code>class NetWork(nn.Module):
    def __init__(self,n_input,n_hidden,n_output):
        super(NetWork,self).__init__()
        self.hidden = nn.Linear(n_input, n_hidden)
        self.output_for_predict = nn.Linear(n_hidden, n_output)
    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.output_for_predict(x)
        return x
network = NetWork(n_input = 1,n_hidden = 8, n_output = 2) 
print(network)  #打印网络结构

</code></pre></li>
<li>
<p>优化器算法： 都是基于梯度下降算法 <a href="https://www.bilibili.com/video/BV1r64y1s7fU?from=search&amp;seid=6481146587654612925&amp;spm_id_from=333.337.0.0">视频讲解</a><br>
sgd算法=miniBatchSGD<br>
Adam=sgd+一阶动量+二阶动量(下降快，同时避免局部最优)<br>
——<a href="https://zhuanlan.zhihu.com/p/32230623">Adam那么棒，为什么还对SGD念念不忘</a></p>
<ul>
<li>
<p>pytorch的优化器以及参数：<a href="https://zhuanlan.zhihu.com/p/64885176">链接</a></p>
</li>
<li>
<p><a href="https://www.jianshu.com/p/e5076a56946c/">不同的样本数量对梯度计算的影响 :</a> 
<img loading="lazy" src="https://upload-images.jianshu.io/upload_images/9064642-17f978d7cc26b8d4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/640/format/webp" alt=""  />
</p>
</li>
</ul>
</li>
<li>
<p>pytorch调用GPU训练</p>
</li>
<li>
<p>channel batch 
channel的两个来源：<br>
最初输入的图片样本的 channels ，取决于图片类型，比如RGB；
卷积操作完成后输出的 out_channels ，取决于卷积核的数量。此时的 out_channels 也会作为下一次卷积时的卷积核的 in_channels；</p>
</li>
<li>
<p>BN的原理：？？？？？？？？？？？？？？？？
<a href="https://blog.csdn.net/u011511601/article/details/79784960">https://blog.csdn.net/u011511601/article/details/79784960</a></p>
</li>
</ol>
<p>batch: 一个batch就是Batch中的蓝色部分，batchsize=N</p>
<p>10:09<br>
<a href="https://www.bilibili.com/video/BV1Ey4y1h7Ke?from=search&amp;seid=12160562612400132573&amp;spm_id_from=333.337.0.0">https://www.bilibili.com/video/BV1Ey4y1h7Ke?from=search&amp;seid=12160562612400132573&amp;spm_id_from=333.337.0.0</a>
01:44<br>
5分钟理解BatchNorm:<br>
<a href="https://www.bilibili.com/video/BV1DM4y1w7J4?from=search&amp;seid=18068463749154619980&amp;spm_id_from=333.337.0.0">https://www.bilibili.com/video/BV1DM4y1w7J4?from=search&amp;seid=18068463749154619980&amp;spm_id_from=333.337.0.0</a></p>
<p>N<em>C</em>H<em>W  ：图片数</em>通道数<em>特征图高</em> 特征图宽</p>
<p><a href="https://support.huaweicloud.com/odevg-training-cann/atlaste_10_0005.html">数据排布格式（format）</a>
在深度学习框架中，多维数据通过多维数组存储，比如卷积神经网络的特征图用 <strong>四维</strong>  数组保存，四个维度分别为批量大小（Batch, N）、特征图高度（Height, H）、特征图宽度（Width, W）以及特征图通道（Channels, C）。<br>
<strong>由于数据只能线性存储</strong>，因为这四个维度有对应的顺序。</p>
<p>Instance Norm才是对一张特征图进行归一化：
<img loading="lazy" src="https://img-blog.csdn.net/20180327163347968?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1NzM3MTY5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70" alt=""  />
</p>
<p>特征：</p>
<p>卷积核可以提取出原图中对应该卷积核的特征，表现形式为卷积之后的featureMapd中对应位置的权重大。<br>
最后经过全连接层 计算分类概率： (我觉得是包含两部分的工作)</p>
<ul>
<li>属于某一类别的训练样本的输出，在经过反向传播的参数修正之后，增大了权重，多次训练之后多次更新权重，那些能代表类别的特征连接的权重肯定大，输入的值经过mlp的权重w计算之后肯定能贡献给softmax的输出层 更大的数值，表现为分类概率<br>
理解CNN的平移、尺度不变性：<br>
对于全连接网络，由于下一层的每个节点都会与上一层进行连接,因此无论输入发生了平移、尺度等什么变换，只要其属性没变，全连接网络更能捕捉其中的不变性。 (因为最终输出是一整个特征图的统计结果，所以不受位置影响) 
<img loading="lazy" src="https://pic2.zhimg.com/80/v2-5277efd6b92989ed9c0405eacb53f679_720w.jpg" alt="全连接层"  />

CNN就是计算原图中的特征的概率分布</li>
</ul>
<p>补充：<br>
权重是如何变得有差异的？
在猫与狗的分类问题中：耳朵是共同特征，所以第一个权重很大，表示这个特征很重要，在全连接层后发现输入是狗耳朵的可能性更大，所以连接狗的权重大。这样权重系数就有了差异
<img loading="lazy" src="http://zouheng22.gitee.io/images_-cabin/research/%E7%90%86%E8%A7%A3%E6%9D%83%E9%87%8D%E4%BD%9C%E7%94%A8.jpg" alt="权重"  />
</p>
<p>理解神经网络：
可以类比傅里叶级数，将复杂 函数拆解为正弦波，类似的神经网络也是将复杂函数拆解为一个一个的感知机(全连接层+激活层==线性函数+激活函数)
只要神经网络有一个隐藏层，那么他就可以<strong>逼近</strong>任意一个连续函数</p>
<p>理解激活函数：<a href="https://www.bilibili.com/video/BV1Yo4y1k7yU?spm_id_from=333.999.0.0">视频</a> &ndash;可视化<br>
全连接层就是世界观<br>
激活函数就是价值观</p>
<p>归一化：
归一化是将像素值进行归一化，而不是将。。。</p>
<p>池化：
Max Pooling (√)
Mean Pooling</p>
<ul>
<li>激活函数的作用</li>
<li>归一化</li>
<li>不需要人工构建特征，而是自动学习特征</li>
<li>什么情况下，会出现梯度消失</li>
<li>像素归一化 与 分布归一化</li>
</ul>
<p><a href="https://www.zhihu.com/question/293640354/answer/2078956333">像素值归一化</a>：
如果输入层 x 很大，在反向传播时候传递到输入层的梯度就会变得很大。梯度大，学习率就得非常小，否则会越过最优。在这种情况下，学习率的选择需要参考输入层数值大小，而直接将数据归一化操作，<strong>能很方便的选择学习率</strong>。（统一标准）</p>
<p><a href="https://blog.csdn.net/sinat_33741547/article/details/87158830">分布归一化</a>：(零均值归一化)</p>
<ul>
<li>
<p>理论认识：</p>
<ul>
<li>归一化的目的是希望输入数据的不同维度的特征具有相近的取值范围，从而能够更快的通过梯度下降找到最优解。<a href="https://blog.csdn.net/cdknight_happy/article/details/106453319">链接</a></li>
<li>尝试解决ICS问题 
避免整体分布逐渐往激活函数的饱和区间移动将每一层的输入作为一个分布看待，由于底层的参数随着训练更新，导致相同的输入分布得到的输出分布改变了。而机器学习中有个很重要的假设：IID独立同分布假设，就是假设训练数据和测试数据是满足相同分布的，这是通过训练数据获得的模型能够在测试集获得好的效果的一个基本保障。(在训练过程中，随着网络加深，分布逐渐发生变动，导致整体分布逐渐往激活函数的饱和区间移动，从而反向传播时底层出现梯度消失，也就是收敛越来越慢的原因。)
加速收敛：<br>
标准化其实就是把大部分激活的值落入非线性函数的线性区内，其对应的导数远离导数饱和区，这样来加速训练收敛过程。<br>
但是：<br>
如果使用标准化，那就相当于把非线性激活函数替换成线性函数了。那么使用非线性激活的意义在哪里呢，多层线性网络跟一层线性网络是等价的，也就是网络的表达能力下降了。 为了保证非线性表达能力，后面又对此打了个补丁，对变换后的满足均值为0方差为1的x进行了scale加上shift操作，形成类似y = s c a l e ∗ x + s h i f t y=scale*x+shifty=scale∗x+shift这种形式
<a href="https://blog.csdn.net/sinat_33741547/article/details/87158830">链接</a></li>
</ul>
</li>
<li>
<p>直观认识：
一般归一化还会做减去均值除以方差的操作, 这种方式可以移除图像的平均亮度值 (intensity)。很多情况下我们对图像的亮度并不感兴趣，而更多地关注其内容，比如在目标识别任务中，图像的整体明亮程度并不会影响图像中存在的是什么物体。此时，在每个样本上减去数据的统计平均值可以移除共同的部分，凸显个体差异。其效果如下所示：
<img loading="lazy" src="https://pic1.zhimg.com/80/v2-43bce25f58eccaa35a9184b4bd154eba_720w.jpg?source=1940ef5c" alt=""  />
</p>
</li>
</ul>
<p>注意：归一化有一个能进行的前提，神经网络的训练的目的是为了得到一个分布，而不是输出准确值，所以进行分布的变换是可以不影响结果，但是可以加快收敛速度，避免梯度消失。</p>
<p>归一化发生在训练的各个阶段：<br>
<a href="https://blog.csdn.net/a1367666195/article/details/105360306/">输入归一化、批量归一化(BN)与层归一化(LN)、输出归一化</a>。
<img loading="lazy" src="https://pic2.zhimg.com/80/v2-7943005f820dba5b04fe6f7da1f37d61_720w.jpg" alt=""  />
</p>
<p>yolov5修改网络
(<a href="https://www.bilibili.com/video/BV18K411n7rc/?spm_id_from=333.788.recommend_more_video.5">https://www.bilibili.com/video/BV18K411n7rc/?spm_id_from=333.788.recommend_more_video.5</a>)</p>
<p>batchsize的设置：
<a href="https://www.zhihu.com/question/32673260">https://www.zhihu.com/question/32673260</a></p>
<p>batchsize变大：（因为采样扔掉的数据就越多，一个epoch花的时间就约少）
一个epoch中迭代的次数少， 运算时间少（但是总体时间不一定变少）
过大会导致，达到相同的精度需要更多的epoch</p>
<p>batchsize变小：
运算时间大，</p>
<p>区别fullbatch与随机梯度下降的区别：
随机梯度下降是为了解决fullbatch的问题
minbatch又是为了解决随机梯度下降的问题
所以现在pytorch中用的sdg==小批量梯度下降（mini-batch gradient decent）
<a href="https://blog.csdn.net/weixin_45698935/article/details/106477624">https://blog.csdn.net/weixin_45698935/article/details/106477624</a><br>
<a href="https://www.pianshen.com/article/95021129552/">https://www.pianshen.com/article/95021129552/</a>
<a href="https://blog.csdn.net/djfjkj52/article/details/116584633">https://blog.csdn.net/djfjkj52/article/details/116584633</a>
<a href="https://www.zhihu.com/question/32673260">https://www.zhihu.com/question/32673260</a>
对于一个大小为N的训练集，如果每个epoch中mini-batch的采样方法采用最常规的N个样本每个都采样一次，设mini-batch大小为b，那么每个epoch所需的迭代次数(正向+反向)为 , 因此完成每个epoch所需的时间大致也随着迭代次数的增加而增加。
由于目前主流深度学习框架处理mini-batch的反向传播时，默认都是先将每个mini-batch中每个instance得到的loss平均化之后再反求梯度，也就是说每次反向传播的梯度是对mini-batch中每个instance的梯度平均之后的结果，所以b的大小决定了相邻迭代之间的梯度平滑程度，b太小，相邻mini-batch间的差异相对过大，那么相邻两次迭代的梯度震荡情况会比较严重，不利于收敛；b越大，相邻mini-batch间的差异相对越小，虽然梯度震荡情况会比较小，一定程度上利于模型收敛，但如果b极端大，相邻mini-batch间的差异过小，相邻两个mini-batch的梯度没有区别了，整个训练过程就是沿着一个方向蹭蹭蹭往下走，很容易陷入到局部最小值出不来。
。
原文链接：https://blog.csdn.net/weixin_39946266/article/details/111629858</p>
<p>实验后确实 大点快</p>
<ol start="12">
<li>
<p>读代码</p>
<ul>
<li>
<p>CNN为什么要接激活函数,与全连接层的激活函数有何区别？<br>
卷积部分的激活函数可以提取更深层特征，全连接层的激活函数可以增加模型的非线性拟合能力！</p>
<p>进一步理解，首先回答以下几个问题：</p>
<ul>
<li>CNN为什么要有多层卷积？<br>
如果堆叠了多层卷积层，则随着层次加深，提取的信息也愈加复杂、抽象，这是深度学习中很有意思的一个地方。最开始的层对简单的边缘有响应，接下来的层对纹理有响应，再后面的层对更加复杂的物体部件有响应。也就是说，随着层次加深，神经元从简单的形状向“高级”信息变化。换句话说，就像我们理解东西的“含义”一样，响应的对象在逐渐变化。</li>
<li>为什么要加relu函数？<br>
因为卷积操作是一种线性操作,多层的线性操作时没有意义的，所以必须加入非线性的因素才能实现多层的效果。只有非线性的多层才能提取更加抽象的特征。</li>
<li>担心在卷积的过程中丢失过多的图像信息？<br>
在卷积的过程中，每一个卷积核对应着一个通道，那么每一个卷积核在进行卷积运算的时候，本来就是只需要有关图像的一丁点信息，只要你的卷积核够多，我觉得最后的featureMap还是能表征图像的。所以在经过一个卷积层的时候，进行一些抹零操作（激活）是不用担心的。抹的越多说不定这个特征越能代表该类别的底层特征，也能减少过拟合的情况（<a href="https://blog.csdn.net/algorithm_image/article/details/78042429">理解relu缓解过拟合</a>）</li>
</ul>
<p>就是说relu不仅仅增加了非线性的表达能力，而且还有其他作用，比如</p>
</li>
<li>
<p>CNN部分的输入输出情况是怎么样？</p>
<pre><code># 定义CNN ：网络的复杂程度影响了一个epoch的运算时间（当然还有数据的数量）
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()

    ##  输入数据格式 [N C H W]
        self.layer1 = nn.Sequential(
            ### 参数:输入通道数  输出通道数 卷积核大小
            nn.Conv2d(1,16,kernel_size=3), # 16, [26 ,26]
            nn.BatchNorm2d(16),
            nn.ReLU(inplace=True))

        self.layer2 = nn.Sequential(
            nn.Conv2d(16,32,kernel_size=3),# 32,[ 24, 24]
            nn.BatchNorm2d(32),
            # inplace表示覆盖运算
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2)) # 32,[ 12,12 ]    (24-2) /2 +1

        self.layer3 = nn.Sequential(
            nn.Conv2d(32,64,kernel_size=3), # 64,[10,10]
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True))

        self.layer4 = nn.Sequential(
            nn.Conv2d(64,128,kernel_size=3),  # 128,[8,8]
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2))  # 128, [4,4]

        self.fc = nn.Sequential(
            nn.Linear(128 * 4 * 4,1024),
            nn.ReLU(inplace=True),
            nn.Linear(1024,128),
            nn.ReLU(inplace=True),
            nn.Linear(128,10))

    def forward(self,x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        ## view与reshape类似 将前面多维度的tensor展平成一维
        ## 参数： 10000=batchSize  128*4*4
        x = x.view(x.size(0),-1)
        x = self.fc(x)
        return x
</code></pre></li>
<li>
<p>Tensor数据为什么展平了还是28*28？<br>
<a href="https://blog.csdn.net/weixin_34570241/article/details/112701227">展平是说在物理空间的存储上是展平了的。是底层是展平存储的。</a></p>
</li>
</ul>
<p>就是说输入到网络的还是28*28，只是底层是展平存储的</p>
<p><a href="https://gitee.com/zouheng22/codes-for-my-blog/blob/master/DeepLearning/Pytorch_Cnn_minst_train.py">典型的CNN代码</a> 详解与注释</p>
</li>
</ol>
<p><a href="https://gitee.com/zouheng22/codes-for-my-blog/blob/master/DeepLearning/Pytorch_Mlp_minst_train.py">感知机的训练</a><br>
<a href="https://gitee.com/zouheng22/codes-for-my-blog/blob/master/DeepLearning/Pytorch_Mlp_minst_evaluation.py">感知机的预测</a><br>
<a href="https://gitee.com/zouheng22/codes-for-my-blog/blob/master/DeepLearning/Pytorch_Cnn_minst_train.py">CNN的训练</a><br>
<a href="https://gitee.com/zouheng22/codes-for-my-blog/blob/master/DeepLearning/Pytorch_Cnn_minst_evaluation.py">CNN的预测</a></p>

</div>
  <footer class="post-footer">
    <ul class="post-tags">
      <li><a href="http://zouheng22.gitee.io/flippedzh/tags/pytorch/">Pytorch</a></li>
    </ul>
<nav class="paginav">
  <a class="prev" href="http://zouheng22.gitee.io/flippedzh/posts/%E6%97%A5%E5%B8%B8/%E9%80%9A%E5%8F%B2/">
    <span class="title">« Prev Page</span>
    <br>
    <span>通史</span>
  </a>
  <a class="next" href="http://zouheng22.gitee.io/flippedzh/posts/markdown%E8%AF%AD%E6%B3%95/">
    <span class="title">Next Page »</span>
    <br>
    <span>markdown语法</span>
  </a>
</nav>

<div class="share-buttons">
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on twitter"
        href="https://weibo.com/">
        <svg height="256px" style="enable-background:new 0 0 256 256;" version="1.1" viewBox="0 0 256 256" width="256px" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
    <g id="Background_1_" style="enable-background:new    ;">
        <g id="Background">
            <g>
                <path d="M249.422,30.68c-2.721-4.986-5.816-9.537-9.793-13.521     c-3.992-3.998-8.709-7.587-13.703-10.314c-8.381-4.576-18.788-6.855-29.002-6.855H59.075c-10.444,0-20.542,2.344-29.265,6.948     c-5.022,2.649-9.588,6.146-13.502,10.126c-3.932,3.998-7.491,8.488-10.046,13.572c-4.289,8.533-6.274,18.478-6.274,28.65v137.43     c0,10.326,1.671,20.678,6.296,29.134c2.681,4.9,6.191,9.86,10.087,13.795c3.934,3.97,8.583,7.225,13.503,9.955     c8.465,4.7,18.842,6.413,29.201,6.413h137.849c10.568,0,20.399-1.523,28.982-6.401c4.739-2.692,9.879-6.113,13.687-9.966     c3.923-3.968,7.2-8.851,9.886-13.799c4.566-8.415,6.533-18.874,6.533-29.131V59.285C256.012,48.978,254.031,39.124,249.422,30.68     z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFE591;"/>
            </g>
        </g>
    </g>
        <g id="Shape_4_1_" style="enable-background:new    ;">
            <g id="Shape_4">
                <g>
                <path d="M169.217,151.074c-2.088-20.866-29.861-35.239-62.04-32.095     c-32.171,3.145-56.568,22.611-54.478,43.479c2.09,20.876,29.865,35.248,62.039,32.11     C146.916,191.425,171.303,171.957,169.217,151.074z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#FFFFFF;"/>
            </g></g>
        </g><g id="Shape_3_1_" style="enable-background:new    ;">
            <g id="Shape_3"><g><path d="M179.092,125.276c-2.738-0.812-4.615-1.361-3.18-4.917     c3.104-7.715,3.425-14.372,0.059-19.121c-6.311-8.908-23.572-8.427-43.359-0.239c0-0.011-6.212,2.687-4.625-2.184     c3.044-9.67,2.585-17.771-2.151-22.444c-10.736-10.616-39.284,0.399-63.764,24.585c-18.333,18.12-28.979,37.325-28.979,53.928     c0,31.76,41.215,51.07,81.536,51.07c52.858,0,88.019-30.345,88.019-54.443C202.648,136.952,190.239,128.692,179.092,125.276z      M114.738,194.569c-32.174,3.138-59.949-11.234-62.039-32.11c-2.09-20.868,22.307-40.335,54.478-43.479     c32.179-3.145,59.952,11.229,62.04,32.095C171.303,171.957,146.916,191.425,114.738,194.569z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#CD201F;"/></g></g></g><g id="Shape_2_1_" style="enable-background:new    ;"><g id="Shape_2"><g><path d="M117.572,134.441c-15.319-3.905-32.636,3.573-39.29,16.802     c-6.777,13.483-0.225,28.456,15.254,33.354c16.032,5.063,34.93-2.701,41.5-17.255     C141.516,153.107,133.426,138.454,117.572,134.441z M105.874,168.889c-3.115,4.863-9.783,6.996-14.806,4.749     c-4.949-2.204-6.411-7.861-3.296-12.604c3.076-4.729,9.52-6.834,14.505-4.785C107.321,158.354,108.931,163.969,105.874,168.889z      M116.131,155.985c-1.125,1.887-3.615,2.794-5.565,2.007c-1.917-0.772-2.518-2.878-1.429-4.735     c1.122-1.844,3.513-2.744,5.427-1.999C116.508,151.952,117.206,154.086,116.131,155.985z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#232323;"/></g></g></g><g id="Shape_1_1_" style="enable-background:new    ;"><g id="Shape_1"><g><path d="M212.111,67.308c-12.48-14.403-30.891-19.894-47.882-16.133     h-0.007c-3.932,0.876-6.438,4.901-5.598,8.986c0.839,4.089,4.706,6.701,8.639,5.829c12.088-2.672,25.168,1.236,34.043,11.467     c8.863,10.23,11.271,24.185,7.475,36.416l0.002,0.004c-1.236,3.986,0.856,8.247,4.689,9.535c3.817,1.288,7.922-0.891,9.16-4.864     c0-0.008,0-0.022,0.003-0.03C227.965,101.311,224.595,81.696,212.111,67.308z M169.621,77.464     c-3.383,0.751-5.54,4.218-4.815,7.743c0.726,3.51,4.052,5.767,7.429,5.001v0.007c4.048-0.89,8.436,0.409,11.404,3.831     c2.975,3.43,3.773,8.104,2.497,12.203h0.007c-1.061,3.422,0.738,7.103,4.03,8.214c3.292,1.097,6.823-0.773,7.884-4.203     c2.603-8.383,0.977-17.936-5.111-24.95C186.871,78.296,177.901,75.632,169.621,77.464z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#DD880C;"/></g></g></g></svg>
    </a>
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on linkedin"
        href="https://www.linkedin.com/shareArticle?mini=true&amp;url=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f&amp;title=Pytorch%e7%9a%84%e4%bd%bf%e7%94%a8&amp;summary=Pytorch%e7%9a%84%e4%bd%bf%e7%94%a8&amp;source=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f">
    
        <svg id="douyin" t="1570181112474" class="icon" viewBox="0 0 1024 1024" version="1.1"
          xmlns="http://www.w3.org/2000/svg" p-id="2916" width="128" height="128">
          <path
            d="M937.386667 423.850667a387.84 387.84 0 0 1-232.874667-77.824v352.341333C704.512 878.250667 565.930667 1024 394.922667 1024S85.333333 878.250667 85.333333 698.368c0-179.882667 138.581333-325.632 309.589334-325.632 17.066667 0 33.706667 1.450667 49.92 4.266667v186.624a131.754667 131.754667 0 0 0-48.64-9.216c-76.288 0-138.154667 65.024-138.154667 145.322666 0 80.213333 61.866667 145.322667 138.24 145.322667 76.202667 0 138.069333-65.109333 138.069333-145.322667V0h172.714667c0 134.485333 103.68 243.541333 231.594667 243.541333v180.309334h-1.28"
            p-id="2917"></path>
        </svg>

    </a>
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on reddit"
        href="https://www.linkedin.com/shareArticle?mini=true&amp;url=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f&amp;title=Pytorch%e7%9a%84%e4%bd%bf%e7%94%a8&amp;summary=Pytorch%e7%9a%84%e4%bd%bf%e7%94%a8&amp;source=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f">
        <svg viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg"><path d="m437 0h-362c-41.398438 0-75 34.601562-75 76v361c0 41.398438 33.601562 75 75 75h362c41.398438 0 75-33.601562 75-75v-361c0-41.398438-33.601562-76-75-76zm0 0" fill="#25d9f8"/><path d="m512 76v361c0 41.398438-33.601562 75-75 75h-181v-512h181c41.398438 0 75 34.601562 75 76zm0 0" fill="#00c0f1"/><g fill="#ececf1"><path d="m121 196h60v211h-60zm0 0"/><path d="m121 106h60v60h-60zm0 0"/><path d="m391 275.800781v131.199219h-60v-121c0-16.5-13.5-30-30-30s-30 13.5-30 30v121h-60v-211h60v11.398438c15.601562-5.097657 25.800781-11.398438 45-11.398438 40.800781 0 75 36.597656 75 79.800781zm0 0"/></g><path d="m391 275.800781v131.199219h-60v-121c0-16.5-13.5-30-30-30s-30 13.5-30 30v121h-15v-211h15v11.398438c15.601562-5.097657 25.800781-11.398438 45-11.398438 40.800781 0 75 36.597656 75 79.800781zm0 0" fill="#e2e2e7"/></svg>
    </a>
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on facebook"
        href="https://facebook.com/sharer/sharer.php?u=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f">
        <svg version="1.1" viewBox="0 0 512 512" xml:space="preserve">
            <path
                d="M449.446,0c34.525,0 62.554,28.03 62.554,62.554l0,386.892c0,34.524 -28.03,62.554 -62.554,62.554l-106.468,0l0,-192.915l66.6,0l12.672,-82.621l-79.272,0l0,-53.617c0,-22.603 11.073,-44.636 46.58,-44.636l36.042,0l0,-70.34c0,0 -32.71,-5.582 -63.982,-5.582c-65.288,0 -107.96,39.569 -107.96,111.204l0,62.971l-72.573,0l0,82.621l72.573,0l0,192.915l-191.104,0c-34.524,0 -62.554,-28.03 -62.554,-62.554l0,-386.892c0,-34.524 28.029,-62.554 62.554,-62.554l386.892,0Z" />
        </svg>
    </a>
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on whatsapp"
        href="https://weixin.qq.com/">
        <svg height="512pt" viewBox="0 -45 512 512" width="512pt" xmlns="http://www.w3.org/2000/svg"><path d="m138.667969 96h-21.335938v21.332031h21.335938zm0 0"/><path d="m245.332031 96h-21.332031v21.332031h21.332031zm0 0"/><path d="m320 224h-21.332031v21.332031h21.332031zm0 0"/><path d="m426.667969 224h-21.335938v21.332031h21.335938zm0 0"/><path d="m469.332031 422.535156-65.730469-32.800781c-13.398437 3.269531-27.140624 4.925781-40.933593 4.933594-82.402344 0-149.335938-57.46875-149.335938-128 0-70.535157 66.933594-128 149.335938-128 82.398437 0 149.332031 57.464843 149.332031 128 0 33.867187-15.066406 65.464843-42.667969 89.464843zm-63.332031-55.46875 42 21.066406v-42l4-3.199218c24.933594-20.265625 38.667969-47.332032 38.667969-76.265625 0-58.800781-57.46875-106.667969-128-106.667969-70.535157 0-128 47.867188-128 106.667969 0 58.796875 57.464843 106.664062 128 106.664062 13.324219.019531 26.597656-1.730469 39.464843-5.199219zm0 0"/><path d="m64 326.535156v-63.335937c-40.800781-28.53125-64-69.734375-64-113.867188 0-82.398437 81.332031-149.332031 181.332031-149.332031s181.335938 66.933594 181.335938 149.332031l-21.335938.402344v-.402344c0-70.53125-71.730469-128-160-128-88.265625 0-160 57.46875-160 128 0 38.535157 21.601563 74.667969 59.203125 99.203125l4.796875 3.199219v40.398437l43.601563-21.734374 3.867187.933593c29.613281 7.433594 60.539063 7.980469 90.398438 1.601563l4.535156 20.800781c-31.761719 6.785156-64.625 6.511719-96.269531-.800781zm0 0"/></svg>
    </a>
    <a target="_blank" rel="noopener noreferrer" aria-label="share Pytorch的使用 on telegram"
        href="https://telegram.me/share/url?text=Pytorch%e7%9a%84%e4%bd%bf%e7%94%a8&amp;url=http%3a%2f%2fzouheng22.gitee.io%2fflippedzh%2fposts%2fpytorch%25E4%25BD%25BF%25E7%2594%25A8%2f">
        <svg version="1.1" xml:space="preserve" viewBox="2 2 28 28">
            <path
                d="M26.49,29.86H5.5a3.37,3.37,0,0,1-2.47-1,3.35,3.35,0,0,1-1-2.47V5.48A3.36,3.36,0,0,1,3,3,3.37,3.37,0,0,1,5.5,2h21A3.38,3.38,0,0,1,29,3a3.36,3.36,0,0,1,1,2.46V26.37a3.35,3.35,0,0,1-1,2.47A3.38,3.38,0,0,1,26.49,29.86Zm-5.38-6.71a.79.79,0,0,0,.85-.66L24.73,9.24a.55.55,0,0,0-.18-.46.62.62,0,0,0-.41-.17q-.08,0-16.53,6.11a.59.59,0,0,0-.41.59.57.57,0,0,0,.43.52l4,1.24,1.61,4.83a.62.62,0,0,0,.63.43.56.56,0,0,0,.4-.17L16.54,20l4.09,3A.9.9,0,0,0,21.11,23.15ZM13.8,20.71l-1.21-4q8.72-5.55,8.78-5.55c.15,0,.23,0,.23.16a.18.18,0,0,1,0,.06s-2.51,2.3-7.52,6.8Z" />
        </svg>
    </a>
</div>

  </footer>
</article>
    </main>
    <footer class="footer">
    <span>&copy; 2022 <a href="http://zouheng22.gitee.io/flippedzh">flipped</a></span>
    <span>
        Powered by
        <a href="https://gohugo.io/" rel="noopener noreferrer" target="_blank">Hugo</a> &
        <a href="https://git.io/hugopapermod" rel="noopener" target="_blank">PaperMod</a>
    </span>
</footer>
<a href="#top" aria-label="go to top" title="Go to Top (Alt + G)">
    <button class="top-link" id="top-link" type="button" accesskey="g">
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 12 6" fill="currentColor">
            <path d="M12 6H0l6-6z" />
        </svg>
    </button>
</a>

<script>
    let menu = document.getElementById('menu')
    menu.scrollLeft = localStorage.getItem("menu-scroll-position");
    menu.onscroll = function () {
        localStorage.setItem("menu-scroll-position", menu.scrollLeft);
    }

    document.querySelectorAll('a[href^="#"]').forEach(anchor => {
        anchor.addEventListener("click", function (e) {
            e.preventDefault();
            var id = this.getAttribute("href").substr(1);
            if (!window.matchMedia('(prefers-reduced-motion: reduce)').matches) {
                document.querySelector(`[id='${decodeURIComponent(id)}']`).scrollIntoView({
                    behavior: "smooth"
                });
            } else {
                document.querySelector(`[id='${decodeURIComponent(id)}']`).scrollIntoView();
            }
            if (id === "top") {
                history.replaceState(null, null, " ");
            } else {
                history.pushState(null, null, `#${id}`);
            }
        });
    });

</script>
<script>
    var mybutton = document.getElementById("top-link");
    window.onscroll = function () {
        if (document.body.scrollTop > 800 || document.documentElement.scrollTop > 800) {
            mybutton.style.visibility = "visible";
            mybutton.style.opacity = "1";
        } else {
            mybutton.style.visibility = "hidden";
            mybutton.style.opacity = "0";
        }
    };

</script>
<script>
    document.getElementById("theme-toggle").addEventListener("click", () => {
        if (document.body.className.includes("dark")) {
            document.body.classList.remove('dark');
            localStorage.setItem("pref-theme", 'light');
        } else {
            document.body.classList.add('dark');
            localStorage.setItem("pref-theme", 'dark');
        }
    })

</script>
<script>
    document.querySelectorAll('pre > code').forEach((codeblock) => {
        const container = codeblock.parentNode.parentNode;

        const copybutton = document.createElement('button');
        copybutton.classList.add('copy-code');
        copybutton.innerText = 'copy';

        function copyingDone() {
            copybutton.innerText = 'copied!';
            setTimeout(() => {
                copybutton.innerText = 'copy';
            }, 2000);
        }

        copybutton.addEventListener('click', (cb) => {
            if ('clipboard' in navigator) {
                navigator.clipboard.writeText(codeblock.textContent);
                copyingDone();
                return;
            }

            const range = document.createRange();
            range.selectNodeContents(codeblock);
            const selection = window.getSelection();
            selection.removeAllRanges();
            selection.addRange(range);
            try {
                document.execCommand('copy');
                copyingDone();
            } catch (e) { };
            selection.removeRange(range);
        });

        if (container.classList.contains("highlight")) {
            container.appendChild(copybutton);
        } else if (container.parentNode.firstChild == container) {
            
        } else if (codeblock.parentNode.parentNode.parentNode.parentNode.parentNode.nodeName == "TABLE") {
            
            codeblock.parentNode.parentNode.parentNode.parentNode.parentNode.appendChild(copybutton);
        } else {
            
            codeblock.parentNode.appendChild(copybutton);
        }
    });
</script>
</body>

</html>
